/*******************************************************************************
/
/ tablero.cpp
/
/ Creado por Roberto García Carvajal.
/
/ Prepara el dibujo de las batallas. Incluye detección de colisiones y gestión
/ de unidades de forma acelerada.
/
/ El dibujo de los tableros está acelerado aunque tengo pendiente una mejora en
/ rendimiento durante el redibujo de zonas.
/
/ Documento bajo licencia GPL.
/
*******************************************************************************/

#include <SDL/SDL.h>
#include <SDL/SDL_image.h>
#include <fstream>
#include <iostream>
#include <map>
#include "tablero.h"
#include "mapa.h"
#include "nucleo.h"
#include "Personajes.h"
#include "svideo.h"


using namespace std;

// Posibles valores: 1,2,4,8,16,32,64
#define VEL_SCROLL 4

// modo depuración.
#define _M_T_DEBUG_ 0

// option flags.
#define OF_T_MODOEDICION 0x00000001
#define OF_T_MODIFICADO  0x00000002
#define OF_T_BLOQ_SCROLL 0x00000004
#define OF_T_VER_MOV     0x00000008
#define OF_T_DIB_PUNT    0x00000010


unsigned int max(unsigned int a,unsigned int b)
{
 if(a > b) return a;
 return b;
}

unsigned int min(unsigned int a,unsigned int b)
{
 if(a > b) return b;
 return a;
}

c_tablero::c_tablero()
{
  // Cargo los tiles.
 fstream ftile("config/tiles.config",ios_base::in);
 {
  unsigned int ntiles;
  // Cargo los tiles lisos.
  ftile >> ntiles;
  ftile.ignore();
  tile = new SDL_Surface*[ntiles];
  for(unsigned int i = 0;i < ntiles;i++)
   tile[i] = NULL;
  for(unsigned int i = 0;i < ntiles;i++)
  {
   char dir[101];
   ftile.getline(dir,100);
   tile[i] = IMG_Load(dir);
   tile[i] = SDL_ConvertSurface(tile[i],tile[i]->format,SDL_HWSURFACE);
  }
  // Ahora cargo las costas, en 3 tandas.
  tile_costas = new SDL_Surface**[3];
  for(unsigned int i = 0;i < 3;i++)
  {
   ftile >> ntiles;
   ftile.ignore();
   tile_costas[i] = new SDL_Surface*[ntiles];
   for(unsigned int j = 0;j < ntiles;j++)
   {
    char dir[101];
    ftile.getline(dir,100);
    tile_costas[i][j] = IMG_Load(dir);
    tile_costas[i][j] = SDL_ConvertSurface(tile_costas[i][j],tile_costas[i][j]->format,SDL_HWSURFACE);
   }
  }

  // Ahora cargo las esquinas, en 3 tandas.
  tile_esquinas = new SDL_Surface**[3];
  for(unsigned int i = 0;i < 3;i++)
  {
   ftile >> ntiles;
   ftile.ignore();
   tile_esquinas[i] = new SDL_Surface*[ntiles];
   for(unsigned int j = 0;j < ntiles;j++)
   {
    char dir[101];
    ftile.getline(dir,100);
    tile_esquinas[i][j] = IMG_Load(dir);
    tile_esquinas[i][j] = SDL_ConvertSurface(tile_esquinas[i][j],tile_esquinas[i][j]->format,SDL_HWSURFACE);
   }
  }
  // Cargo los minitiles.
  ftile >> ntiles;
  ftile.ignore();
  minitile = new SDL_Surface*[ntiles];
  for(unsigned int i = 0;i < ntiles;i++)
  {
   char dir[101];
   ftile.getline(dir,100);
   minitile[i] = IMG_Load(dir);
   minitile[i] = SDL_ConvertSurface(minitile[i],minitile[i]->format,SDL_HWSURFACE);
  }
 }
 ftile.close();

 fondominimapa = SDL_CreateRGBSurface(SDL_HWSURFACE,640,480,32,0,0,0,0);
 fondominimapa = IMG_Load("./graficos/fondominimapa.png");
 fondominimapa = SDL_ConvertSurface(fondominimapa,fondominimapa->format,SDL_HWSURFACE);

 t_personajes = SDL_CreateRGBSurface(SDL_HWSURFACE, 768, 576, 32, 0, 0, 0, 0);
 t_tablero = SDL_CreateRGBSurface(SDL_HWSURFACE, 768, 576, 32, 0, 0, 0, 0);
 t_rtablero.x = 0;
 t_rtablero.y = 0;
 t_rtablero.w = 640;
 t_rtablero.h = 440;
 t_x = 0;
 t_y = 0;
 
 FLAGS = FLAGS & ~OF_T_MODOEDICION;
 contador = 200;
 rejilla = IMG_Load("./graficos/rejilla.png");
 rejilla = SDL_ConvertSurface(rejilla,rejilla->format,SDL_HWSURFACE);

 // Cargo las imagenes de las unidades patriotas.
 fstream fup("config/up.img",ios_base::in);
 {
  unsigned int nup;
  fup >> nup;
  fup.ignore();
  up = new SDL_Surface*[nup];
  for(unsigned int i = 0;i < nup;i++)
  {
   char dir[101];
   fup.getline(dir,100);
   up[i] = NULL;
   up[i] = IMG_Load(dir);
   if(_M_T_DEBUG_)
    if(up[i] == NULL)
     cout << "[tablero]-> CARGA DE UNIDAD FALLIDA: PATRIOTA: " << i << endl;
    else
     cout << "[tablero]-> CARGA DE UNIDAD: PATRIOTA: " << i << endl;
  }
 }
 fup.close();
 
 // Cargo las imagenes de las unidades invasoras.
 fstream fui("config/ui.img",ios_base::in);
 {
  unsigned int nui;
  fui >> nui;
  fui.ignore();
  ui = new SDL_Surface*[nui];
  for(unsigned int i = 0;i < nui;i++)
  {
   char dir[101];
   fui.getline(dir,100);
   ui[i] = NULL;
   ui[i] = IMG_Load(dir);
   if(_M_T_DEBUG_)
    if(ui[i] == NULL)
     cout << "[tablero]-> CARGA DE UNIDAD FALLIDA: INVASORA: " << i << endl;
    else
     cout << "[tablero]-> CARGA DE UNIDAD: INVASORA: " << i << endl;
  }
 }
 fui.close();
 
 FLAGS = 0;
 contador_minimapa = 80;
}

void c_tablero::asociar_mapa(c_mapa mapa)
{
 t_x = 0;
 t_y = 0;
 t_rtablero.x = 0;
 t_rtablero.y = 0;
 t_mapa = mapa;
 // Genero costas...
 // Reservo memoria para los submapas.
 t_tablero_costas = new int**[3];
 t_tablero_esquinas = new int**[3];
 t_tablero_costas[0] = new int*[t_mapa.alto()];
 t_tablero_costas[1] = new int*[t_mapa.alto()];
 t_tablero_costas[2] = new int*[t_mapa.alto()];
 t_tablero_esquinas[0] = new int*[t_mapa.alto()];
 t_tablero_esquinas[1] = new int*[t_mapa.alto()];
 t_tablero_esquinas[2] = new int*[t_mapa.alto()];
 t_mapamov = new int*[t_mapa.alto()];
 for(unsigned int i = 0;i < t_mapa.alto();i++)
 {
  t_tablero_costas[0][i] = new int[t_mapa.ancho()];
  t_tablero_costas[1][i] = new int[t_mapa.ancho()];
  t_tablero_costas[2][i] = new int[t_mapa.ancho()];
  t_tablero_esquinas[0][i] = new int[t_mapa.ancho()];
  t_tablero_esquinas[1][i] = new int[t_mapa.ancho()];
  t_tablero_esquinas[2][i] = new int[t_mapa.ancho()];
  t_mapamov[i] = new int[t_mapa.ancho()];
  for(unsigned int j = 0;j < t_mapa.ancho();j++)
   t_mapamov[i][j] = 99;
 }
 // Ahora genero la costa o esquina que necesite. Además, creo el minimapa.
 minimapa = SDL_CreateRGBSurface(SDL_HWSURFACE,t_mapa.ancho()*6,t_mapa.alto()*6,32,0,0,0,0);
 minimapau = SDL_CreateRGBSurface(SDL_HWSURFACE,t_mapa.ancho()*6,t_mapa.alto()*6,32,0,0,0,0);
 SDL_Rect destino;

 recostear();

 minimapaf = SDL_CreateRGBSurface(SDL_HWSURFACE,640,440,32,0,0,0,0);
 destino.x = 0;
 destino.y = 0;
 destino.w = 640;
 destino.h = 440;
 SDL_BlitSurface(fondominimapa,NULL,minimapaf,&destino);
 destino.w = minimapa->w;
 destino.h = minimapa->h;
 destino.x = 10;
 destino.y = 10;
 SDL_BlitSurface(minimapa,NULL,minimapaf,&destino);
}

void c_tablero::recostear()
{
 SDL_Rect destino;
 destino.x = 0;
 destino.y = 0;
 destino.w = 6;
 destino.h = 6;
 // Pongo las matrices a 0.
 for(unsigned int i = 0;i < t_mapa.ancho();i++)
  for(unsigned int j = 0;j < t_mapa.alto();j++)
   for(unsigned int m = 0;m < 3;m++)
    {
     t_tablero_costas[m][j][i] = 0;
     t_tablero_esquinas[m][j][i] = 0;
    }
 // Esto está explicado en la presentación.
 for(unsigned int i = 0;i < t_mapa.ancho();i++)
 {
  for(unsigned int j = 0;j < t_mapa.alto();j++)
  {
   destino.x = i*6;
   destino.y = j*6;
   SDL_BlitSurface(minitile[t_mapa.mapa()[j][i]],NULL,minimapa,&destino);
   for(int m = t_mapa.mapa()[j][i]+1;m < 4;m++)
   {
     if(observar_casilla(i-1,j) >= m)
      t_tablero_costas[m-1][j][i] += 1;
     if(observar_casilla(i,j+1) >= m)
      t_tablero_costas[m-1][j][i] += 2;
     if(observar_casilla(i+1,j) >= m)
      t_tablero_costas[m-1][j][i] += 4;
     if(observar_casilla(i,j-1) >= m)
      t_tablero_costas[m-1][j][i] += 8;
      
     if(observar_casilla(i-1,j+1) >= m)
      t_tablero_esquinas[m-1][j][i] += 1;
     if(observar_casilla(i+1,j+1) >= m)
      t_tablero_esquinas[m-1][j][i] += 2;
     if(observar_casilla(i+1,j-1) >= m)
      t_tablero_esquinas[m-1][j][i] += 4;
     if(observar_casilla(i-1,j-1) >= m)
      t_tablero_esquinas[m-1][j][i] += 8;
   }
  }
 }

}

void c_tablero::moverse(int mov)
{
 // Si el scroll no está bloqueado.
 if(!(FLAGS & OF_T_BLOQ_SCROLL))
 {
  switch(mov)
  { // Determino el tipo de movimiento, y si no he llegado al final del tablero, me muevo.
   case 0:
   {
    if(t_rtablero.x == 128)
    {
     if(t_x < (t_mapa.ancho() - 12))
     {
      t_x++;
      regenerar();
      t_rtablero.x = 64 + VEL_SCROLL;
     }
    }
    else
    {
     t_rtablero.x += VEL_SCROLL;
    }
   } break;
   case 1:
   {
    if(t_rtablero.x == 0)
    {
     if(t_x > 0)
     {
      t_x--;
      regenerar();
      t_rtablero.x = 64 - VEL_SCROLL;
     }
    }
    else
    {
     t_rtablero.x -= VEL_SCROLL;
    }
   } break;
   case 2:
   {
    if(t_rtablero.y == 128)
    {
     if(t_y < (t_mapa.alto() - 9))
     {
      t_y++;
      regenerar();
      t_rtablero.y = 64 + VEL_SCROLL;
     }
    }
    else
    {
     t_rtablero.y += VEL_SCROLL;
    }
   } break;
   case 3:
   {
    if(t_rtablero.y == 0)
    {
     if(t_y > 0)
     {
      t_y--;
      regenerar();
      t_rtablero.y = 64 - VEL_SCROLL;
     }
    }
    else
    {
     t_rtablero.y -= VEL_SCROLL;
    }
   } break;
  }
 }
}

void c_tablero::regenerar()
{
 if(_M_T_DEBUG_)
  cout << "[tablero]-> Comienza regenerado."<< endl;
 SDL_Rect destino;
 destino.x = 0;
 destino.y = 0;
 destino.w = 64;
 destino.h = 64;
 // Crea una superficie colocando cada tile en su sitio.
 for(unsigned int j = 0;j < 9;j++)
 {
  for(unsigned int i = 0;i < 12;i++)
  {
   int yf,xf;
   yf = t_y+j;
   xf = t_x+i;
   SDL_BlitSurface(tile[t_mapa.mapa()[yf][xf]],NULL,t_tablero,&destino);
   SDL_BlitSurface(tile_costas[0][t_tablero_costas[0][yf][xf]],NULL,t_tablero,&destino);
   SDL_BlitSurface(tile_esquinas[0][t_tablero_esquinas[0][yf][xf]],NULL,t_tablero,&destino);
   SDL_BlitSurface(tile_costas[1][t_tablero_costas[1][yf][xf]],NULL,t_tablero,&destino);
   SDL_BlitSurface(tile_esquinas[1][t_tablero_esquinas[1][yf][xf]],NULL,t_tablero,&destino);
   SDL_BlitSurface(tile_costas[2][t_tablero_costas[2][yf][xf]],NULL,t_tablero,&destino);
   SDL_BlitSurface(tile_esquinas[2][t_tablero_esquinas[2][yf][xf]],NULL,t_tablero,&destino);
   if(!(FLAGS & OF_T_MODOEDICION))
   {
    if(m_ud_l[yf][xf] != 99)
    {
     SDL_BlitSurface(ud_locales[m_ud_l[yf][xf]],NULL,t_tablero,&destino);
     SDL_BlitSurface(tile[6],NULL,t_tablero,&destino);
    }
    if(m_ud_r[yf][xf] != 99)
    {
     SDL_BlitSurface(ud_remotas[m_ud_r[yf][xf]],NULL,t_tablero,&destino);
     SDL_BlitSurface(tile[7],NULL,t_tablero,&destino);
    }
   }
   destino.x += 64;
  }
  destino.x = 0;
  destino.y += 64;
 }
 if(FLAGS & OF_T_MODOEDICION)
 {
  destino.x = 0;
  destino.y = 0;
  destino.w = rejilla->w;
  destino.h = rejilla->h;
  SDL_BlitSurface(rejilla,NULL,t_tablero,&destino);
 }
 if(_M_T_DEBUG_)
  cout << "[tablero]-> Fin regenerado." << endl;
}

void c_tablero::hmodoedicion()
{
 FLAGS = FLAGS | OF_T_MODOEDICION;
 contador = 200;
 pincel = 0;
 regenerar();
}

void c_tablero::dmodoedicion()
{
 FLAGS = FLAGS & ~OF_T_MODOEDICION;
 regenerar();
}

void c_tablero::pintar(int posx, int posy)
{
 int x,y;
 x = (posx + t_rtablero.x) / 64 + t_x;
 y = (posy + t_rtablero.y) / 64 + t_y;
 // Si no estoy fuera del tablero y la casilla tiene distinto tipo.
 if(((unsigned)x < t_mapa.ancho()) && ((unsigned)y < t_mapa.alto()) && ((unsigned)t_mapa.mapa()[y][x] != pincel))
 {
  // Pintar el mapa.
  t_mapa.modificar(x,y,pincel);

  // Redibujar el tile.
  SDL_Rect destino;
  destino.x = (x - t_x) * 64;
  destino.y = (y - t_y) * 64;
  destino.w = 64;
  destino.h = 64;
  SDL_BlitSurface(tile[pincel],NULL,t_tablero,&destino);

  // Redibujar rejilla.
  destino.x = 0;
  destino.y = 0;
  destino.w = rejilla->w;
  destino.h = rejilla->h;
  SDL_BlitSurface(rejilla,NULL,t_tablero,&destino);

  // Redibujar el tile del minimapa.
  destino.x = x * 6;
  destino.y = y * 6;
  destino.w = 6;
  destino.h = 6;
  SDL_BlitSurface(minitile[pincel],NULL,minimapa,&destino);

  destino.w = minimapa->w;
  destino.h = minimapa->h;
  destino.x = 10;
  destino.y = 10;
  SDL_BlitSurface(minimapa,NULL,minimapaf,&destino);
  FLAGS = FLAGS | OF_T_MODIFICADO;
 }
}

void c_tablero::ataque_remoto(int idg,SDL_Surface * dano)
{
 pair<int,int> temp;
 temp = culi[idg];
 if(dano)
 {
  temp.first -= t_x;
  temp.second -= t_y;
  temp.first *= 64;
  temp.second *= 64;
  SDL_Rect destino;
  destino.x = temp.first;
  destino.y = temp.second;
  destino.w = dano->w;
  destino.h = dano->h;
  SDL_BlitSurface(dano,NULL,t_tablero,&destino);
  SDL_FreeSurface(dano);
 }
 // animacion.
}

void c_tablero::movimiento_remoto(int idg,int x, int y)
{
 pair<int,int> temp,temp2;
 temp = curi[idg];
 m_ud_r[y][x] = m_ud_r[temp.second][temp.first];
 m_ud_r[temp.second][temp.first] = 99;
 temp2 = curc[temp];
 curc.erase(temp);
 temp.first = x;
 temp.second = y;
 curc[temp] = temp2;
 curi.erase(idg);
 curi[idg] = temp;
 regenerar();
 regenerar_minimapau();
}

void c_tablero::restaurar_movimiento()
{
 movul = movul_backup;
}

void c_tablero::elimina_unidad_local(int idg)
{
 movul.erase(idg);
 pair<int,int> temp;
 temp = culi[idg];
 m_ud_l[temp.second][temp.first] = 99;
 culc.erase(temp);
 culi.erase(idg);
 regenerar();
 regenerar_minimapau();
}

void c_tablero::elimina_unidad_remota(int idg)
{
 pair<int,int> temp;
 temp = curi[idg];
 m_ud_r[temp.second][temp.first] = 99;
 curc.erase(temp);
 curi.erase(idg);
 regenerar();
 regenerar_minimapau();
}

void c_tablero::click(int posx,int posy)
{
 int x,y;
 SDL_Surface * dano;
 x = (posx + t_rtablero.x) / 64 + t_x;
 y = (posy + t_rtablero.y) / 64 + t_y;
 if(_M_T_DEBUG_)
  cout << "X: " << x << " Y: " << y << endl;
 if(FLAGS & OF_T_VER_MOV)
 {
  FLAGS = FLAGS & ~OF_T_VER_MOV;
  FLAGS = FLAGS & ~OF_T_BLOQ_SCROLL;
  if(t_mapamov[y][x] == 99)
  {
   if(m_ud_r[y][x] != 99)
   {
    pair<int,int> c;
    c.first = x;
    c.second = y;
    if(movul[culc[c_u_mov].first])
    {
     cout << "Unidad atacante: " << curc[c_u_mov].first << endl;
     dano = svideo->ataque_local(culc[c_u_mov].first,curc[c].first);
     if(dano)
     {
      cout << "He entrado: " << posx + t_rtablero.x << " "<< posy + t_rtablero.y << " " << dano->w << " " << dano->h << endl;
      movul.erase(culc[c_u_mov].first);
      movul[culc[c_u_mov].first] = 0;
      FLAGS = FLAGS | OF_T_DIB_PUNT;
      // animacion.
     }
    }
   }
  }
  else
  {
   if(m_ud_l[y][x] == 99)
   {
    if(m_ud_r[y][x] == 99)
    {
     m_ud_l[y][x] = m_ud_l[c_u_mov.second][c_u_mov.first];
     m_ud_l[c_u_mov.second][c_u_mov.first] = 99;
     pair<int,int> temp;
     temp = culc[c_u_mov];
     movul.erase(temp.first);
     movul[temp.first] = t_mapamov[y][x];
     culc.erase(c_u_mov);
     culi.erase(temp.first);
     c_u_mov.first = x;
     c_u_mov.second = y;
     culc[c_u_mov] = temp;
     culi[temp.first] = c_u_mov;
     svideo->movimiento_local(temp.first,x,y,t_mapamov[y][x]);
     regenerar_minimapau();
    }
    else
    {
     pair<int,int> c;
     c.first = x;
     c.second = y;
     if(movul[culc[c_u_mov].first])
     {
      dano = svideo->ataque_local(culc[c_u_mov].first,curc[c].first);
      if(dano)
      {
       cout << "He entrado: " << posx + t_rtablero.x << " "<< posy + t_rtablero.y << " " << dano->w << " " << dano->h << endl;
       movul.erase(culc[c_u_mov].first);
       movul[culc[c_u_mov].first] = 0;
       // animacion.
       FLAGS = FLAGS | OF_T_DIB_PUNT;
      }
     }
    }
   }
  }
  regenerar();
  if(FLAGS & OF_T_DIB_PUNT)
  {
   cout << "DIBUJANDO PUNTUACION" << endl;
   FLAGS = FLAGS & ~OF_T_DIB_PUNT;
   SDL_Rect destino;
   destino.x = posx + t_rtablero.x;
   destino.y = posy + t_rtablero.y;
   destino.w = dano->w;
   destino.h = dano->h;
   SDL_BlitSurface(dano,NULL,t_tablero,&destino);
   SDL_FreeSurface(dano);
  }
  for(unsigned int i = 0;i < t_mapa.alto();i++)
   for(unsigned int j = 0;j < t_mapa.ancho();j++)
    t_mapamov[i][j] = 99;
 }
 else
 {
  if(m_ud_l[y][x] != 99)
  {
   ////////////////////////////////////
   c_u_mov.first = x;
   c_u_mov.second = y;
   pair<int,int> temp;
   temp.first = x;
   temp.second = y;
   svideo->vida(culc[temp].first,0);
   int mov = movul[culc[temp].first];
   if(mov > 0) // Atención cambio aqui de >= a >
   {
    FLAGS = FLAGS | OF_T_BLOQ_SCROLL | OF_T_VER_MOV;
    queue<pair<int,pair<int,int> > > movimientos;
    pair<int,pair<int,int> > celda,celda2;
    switch(t_mapa.mapa()[y][x])
    {
     case 0: break;
     case 1: mov+=2; break;
     case 2: mov+=1; break;
     case 3: mov+=3; break;
    }
    celda.first = mov;
    celda.second.first = x;
    celda.second.second = y;
    movimientos.push(celda);
    SDL_Rect destino;
    destino.w = 64;
    destino.h = 64;
    while(!movimientos.empty())
    {
     celda = movimientos.front();
     movimientos.pop();
     mov = celda.first;
     x = celda.second.first;
     y = celda.second.second;
     switch(t_mapa.mapa()[y][x])
     {
      case 0: mov=-1; break;
      case 1: mov-=2; break;
      case 2: mov-=1; break;
      case 3: mov-=3; break;
     }
     if(mov>=0)
     {
      if(((t_mapamov[y][x] < mov) || (t_mapamov[y][x] == 99)) && (m_ud_r[y][x] == 99))
      {
       if(t_mapamov[y][x] == 99)
       {
        destino.x = (x - t_x) * 64;
        destino.y = (y - t_y) * 64;
        SDL_BlitSurface(tile[4],NULL,t_tablero,&destino);
       }
       t_mapamov[y][x] = mov;
       celda.first = mov;
       if(y)
       {
        celda.second.first = x;
        celda.second.second = y-1;
        movimientos.push(celda);
       }
       if((unsigned)y < (t_mapa.alto() - 1))
       {
        celda.second.first = x;
        celda.second.second = y+1;
        movimientos.push(celda);
       }
       if(x)
       {
        celda.second.first = x-1;
        celda.second.second = y;
        movimientos.push(celda);
       }
       if((unsigned)x < (t_mapa.ancho() - 1))
       {
        celda.second.first = x+1;
        celda.second.second = y;
        movimientos.push(celda);
       }
      }
     }
    }
   }
   ////////////////////////////////////
  }
  else if(m_ud_r[y][x] != 99)
  {
   pair<int,int> temp;
   temp.first = x;
   temp.second = y;
   svideo->vida(curc[temp].first,1);
  }
 }
}

void c_tablero::epincel(int x)
{
 pincel = x;
}

int c_tablero::observar_casilla(int i,int j)
{
 if(i < 0 || j < 0 || (unsigned)i >= t_mapa.ancho() || (unsigned)j >= t_mapa.alto())
  return 0;
 return t_mapa.mapa()[j][i];
}

SDL_Surface * c_tablero::dminimapa()
{
 if(!(FLAGS & OF_T_MODOEDICION))
 {
  SDL_Rect destino;
  if(contador_minimapa == 40)
  {
   destino.w = minimapau->w;
   destino.h = minimapau->h;
   destino.x = 10;
   destino.y = 10;
   SDL_BlitSurface(minimapau,NULL,minimapaf,&destino);
  }
  else if(contador_minimapa == 0)
  {
   destino.w = minimapa->w;
   destino.h = minimapa->h;
   destino.x = 10;
   destino.y = 10;
   SDL_BlitSurface(minimapa,NULL,minimapaf,&destino);
   contador_minimapa = 81;
  }
 }
 contador_minimapa--;
 return minimapaf;
}


SDL_Surface * c_tablero::tablero() 
{
 if(FLAGS & OF_T_MODOEDICION)
 {
  if(contador)
   contador--;
  else
  {
   if(FLAGS & OF_T_MODIFICADO)
   {
    recostear();
    regenerar();
   }
   contador = 200;
  }
 }
 
 return t_tablero;
}

void c_tablero::jugador_local(int ejer,vector<personaje> p,vector<coordenada> c)
{
 ejer_l = ejer;
 m_ud_l = new int*[t_mapa.alto()];
 for(unsigned int i = 0;i < t_mapa.alto();i++)
  m_ud_l[i] = new int[t_mapa.ancho()];
 for(unsigned int i = 0;i < t_mapa.alto();i++)
  for(unsigned int j= 0;j < t_mapa.ancho();j++)
   m_ud_l[i][j] = 99;

 
 pair<int,int> temp,temp2;
 int id;
 
 if(c.size() != p.size())
 {
  cout << "[tablero]-> ¡ATENCION! ERROR GRAVE DE SINCRONIZACION INTERNA EN LOS VECTORES DE UNIDADES LOCALES." <<endl;
 }

 for(unsigned int i = 0;i < p.size();i++)
 {
  if((unsigned)p[i].idg != c[i].id)
  {
   cout << "[tablero]-> ¡ATENCION! ERROR GRAVE DE SINCRONIZACION INTERNA EN LOS VECTORES DE UNIDADES LOCALES." << endl;
  }
  temp.first = c[i].x;
  temp.second = c[i].y;
  temp2.first = p[i].idg;
  id = temp2.first;
  temp2.second = p[i].im1;
  culi[id] = temp;
  culc[temp] = temp2;
  movul[id] = p[i].mov;
  /*culi.insert(temp);
  culc.insert(temp);*/
  m_ud_l[temp.second][temp.first] = temp2.second;
 }
 movul_backup = movul;
 ud_locales = new SDL_Surface*[12];
 if(ejer_l)
 {
  for(unsigned int i = 0;i < 12;i++)
  {
   ud_locales[i] = SDL_ConvertSurface(ui[i],ui[i]->format,SDL_HWSURFACE);
  }
 }
 else
 {
  for(unsigned int i = 0;i < 12;i++)
  {
   ud_locales[i] = SDL_ConvertSurface(up[i],up[i]->format,SDL_HWSURFACE);
  }
 }
}

void c_tablero::jugador_remoto(int ejer,vector<personaje> p,vector<coordenada> c)
{
 ejer_r = ejer;

 m_ud_r = new int*[t_mapa.alto()];
 for(unsigned int i = 0;i < t_mapa.alto();i++)
  m_ud_r[i] = new int[t_mapa.ancho()];
 
 for(unsigned int i = 0;i < t_mapa.alto();i++)
  for(unsigned int j= 0;j < t_mapa.ancho();j++)
   m_ud_r[i][j] = 99;
 
 pair<int,int> temp,temp2;
 int id;

 if(c.size() != p.size())
 {
  cout << "[tablero]-> ¡ATENCION! ERROR GRAVE DE SINCRONIZACION INTERNA EN LOS VECTORES DE UNIDADES REMOTAS." <<endl;
 }

 for(unsigned int i = 0;i < p.size();i++)
 {
  if((unsigned)p[i].idg != c[i].id)
  {
   cout << "[tablero]-> ¡ATENCION! ERROR GRAVE DE SINCRONIZACION INTERNA EN LOS VECTORES DE UNIDADES REMOTAS." << endl;
  }
  temp.first = c[i].x;
  temp.second = c[i].y;
  temp2.first = p[i].idg;
  id = temp2.first;
  temp2.second = p[i].im1;
  curi[id] = temp;
  curc[temp] = temp2;
  /*culi.insert(temp);
  culc.insert(temp);*/
  m_ud_r[temp.second][temp.first] = temp2.second;
 }
 ud_remotas = new SDL_Surface*[12];
 if(ejer_r)
 {
  for(unsigned int i = 0;i < 12;i++)
  {
   ud_remotas[i] = SDL_ConvertSurface(ui[i],ui[i]->format,SDL_HWSURFACE);
  }
 }
 else
 {
  for(unsigned int i = 0;i < 12;i++)
  {
   ud_remotas[i] = SDL_ConvertSurface(up[i],up[i]->format,SDL_HWSURFACE);
  }
 }
 regenerar_minimapau();
}

void c_tablero::regenerar_minimapau()
{
 SDL_Rect destino;
 destino.x = 0;
 destino.y = 0;
 destino.h = minimapa->h;
 destino.w = minimapa->w;
 SDL_BlitSurface(minimapa,NULL,minimapau,&destino);
 destino.h = 6;
 destino.w = 6;
 for(unsigned int i = 0;i < t_mapa.alto();i++)
 {
  for(unsigned int j = 0;j < t_mapa.ancho();j++)
  {
   if(m_ud_l[i][j] != 99)
   {
    SDL_BlitSurface(minitile[5],NULL,minimapau,&destino);
   }
   if(m_ud_r[i][j] != 99)
   {
    SDL_BlitSurface(minitile[6],NULL,minimapau,&destino);
   }
   destino.x += 6;
  }
  destino.y +=6;
  destino.x = 0;
 }
}

